#-*- coding:utf8 -*-
 
#se importa el modulo html para la ayuda en html
import  wx.html as  html
import os
try:
    import wx
except ImporError:
    raise ImportError, 'se requiere el módulo wxPython'

#Variable que determina la extención del archivo en Guardar como
wildcard = "Código fuente Python (*.py)|*.py|"     \
           "Python compilado (*.pyc)|*.pyc|" \
           "Archivo egg (*.egg)|*.egg|"        \
           "Archivo de textl plano (*.txt)|*.txt|"        \
           "Todos los archivos (*.*)|*.*"


class editor(wx.Frame):
    def __init__(self,parent,id,title):
        wx.Frame.__init__(self,parent,id,title, size=(600,500))
        #variables
        self.contador = 0
        self.fueGcomo = False
        self.dirname = False
        self.filename = False
        self.textoInicial = ''
        #Referencia a la clase padre
        self.parent = parent
        self.CenterOnScreen()
        #Se coloca el textCtrl en un boxSizerSizer con un borde celeste
        panel = wx.Panel(self, -1)
        panel.SetBackgroundColour ('#EEEEEE')
        vbox = wx.BoxSizer(wx.VERTICAL)
        self.tc = wx.TextCtrl(panel, -1, u'',style=wx.TE_MULTILINE)
        self.tc.SetFocus()
        vbox.Add(self.tc, 1, wx.EXPAND | wx.ALL, 18)
        panel.SetSizer(vbox)
        #Se crea una barra menú
        menuBar = wx.MenuBar()
        #Se crea un menu 
        menuArchivo = wx.Menu()
        #Se agrega elementos ej: Archivo
        self.nuevo = menuArchivo.Append(wx.ID_NEW, u"&Nuevo\tCtrl-N", u'Crea un nuevo documento')
        menuArchivo.AppendSeparator()
        self.abrir = menuArchivo.Append(wx.ID_OPEN, u"&Abrir\tCtrl-O", u'Abre un archivo existente')
        menuArchivo.AppendSeparator()
        self.guardar = menuArchivo.Append(wx.ID_SAVE, u"&Guardar\tCtrl-H", u'Guarda el archivo actual')
        self.guardarComo = menuArchivo.Append(wx.ID_SAVEAS, u"Guardar &como\tCtrl-S", u'guarda el archivo actual con un nombre determinado')
        menuArchivo.AppendSeparator()
        self.salir = menuArchivo.Append(wx.ID_EXIT, u"&Salir\tCtrl-Q", u'Terminar el programa')
        #La barra menú agrega menúArchivo
        menuBar.Append(menuArchivo,u'&Archivo')
        #Editar
        menuEditar = wx.Menu()
        self.cortar = menuEditar.Append(wx.ID_CUT, u'&Cortar\tCtrl-X',u'Corta el texto seleccionado')
        self.copiar = menuEditar.Append(wx.ID_COPY, u'C&opiar\tCtrl-C',u'Copia el texto seleccionado')
        self.pegar = menuEditar.Append(wx.ID_PASTE, u'&Pegar\tCtrl-V',u'Pega el texto copiado ó cortado')
        menuEditar.AppendSeparator()
        self.seleccionar_todo = menuEditar.Append(wx.ID_SELECTALL,u'&Seleccionar_todo\tCtrl-A', u'Permite seleccionar todo')
        menuEditar.AppendSeparator()
        self.borrar = menuEditar.Append(wx.ID_DELETE, u'&Borrar\tCtrl-D',u'Borra todo lo seleccionado')              
        menuBar.Append(menuEditar, u'&Editar')
        #Formato
        menuFormato = wx.Menu()
        self.fuente = menuFormato.Append(wx.ID_BOLD, u'&Fuente\tCtrl-F',u'Permite cambiar al texto de funete y tamaño')
        menuBar.Append(menuFormato, u'&Formato')
        #ver
        #menuVer = wx.Menu()
        #menuVer.Append(-1, u"V&ista previa", u"Vista del documento finalizado")
        #menuBar.Append(menuVer, u'&Ver')
        #Ayuda
        menuAyuda = wx.Menu()
        self.manual = menuAyuda.Append(wx.ID_HELP, u'&Ayuda',u'Abre el documento de ayuda de Editext')
        #menuAyuda.AppendSeparator()
        self.acercaDe= menuAyuda.Append(wx.ID_ABOUT,u'&Acerca de',u'Acerca de esta aplicación')
        menuBar.Append(menuAyuda, u'A&yuda')
        #Bindeo
        #menuArchivo
        self.Bind(wx.EVT_MENU, self.OnNuevo)
        self.Bind(wx.EVT_MENU, self.OnAbrir, self.abrir)
        self.Bind(wx.EVT_MENU, self.OnGuardar, self.guardar)
        self.Bind(wx.EVT_MENU, self.OnGuardar_como, self.guardarComo)
        self.Bind(wx.EVT_MENU, self.OnSalir, self.salir)
        #--------------------------------------------------------------
        #MenuEditar
        self.Bind(wx.EVT_MENU,self.OnElegirFuente, self.fuente)
        self.Bind(wx.EVT_MENU, self.OnCortar, self.cortar)
        self.Bind(wx.EVT_MENU, self.OnCopiar, self.copiar)
        self.Bind(wx.EVT_MENU, self.OnPegar, self.pegar)
        self.Bind(wx.EVT_MENU, self.Seleccionar_todo,self.seleccionar_todo) 
        self.Bind(wx.EVT_MENU, self.OnBorrar, self.borrar)
        #--------------------------------------------------------------
        #Menú ayuda
        self.Bind(wx.EVT_MENU, self.OnManual, self.manual)
        self.Bind(wx.EVT_MENU, self.OnAcerca_de, self.acercaDe)
        #--------------------------------------------------------------
        #ToolBar
        # el tsize fija el tamaño de las imagenes 
        tsize=(25,25)
        #imagenes de la ToolBar()
        #menuArchivo
        nuevo_bmp =  wx.ArtProvider.GetBitmap(wx.ART_NEW, wx.ART_TOOLBAR, tsize)
        abrir_bmp = wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN, wx.ART_TOOLBAR, tsize)
        guardar_bmp = wx.ArtProvider.GetBitmap(wx.ART_FILE_SAVE, wx.ART_TOOLBAR, tsize)
        guardarComo_bmp = wx.ArtProvider.GetBitmap(wx.ART_FILE_SAVE_AS, wx.ART_TOOLBAR, tsize)
        salir_bmp = wx.ArtProvider.GetBitmap(wx.ART_QUIT, wx.ART_TOOLBAR, tsize)             
        #menuEditar
        cortar_bmp = wx.ArtProvider.GetBitmap(wx.ART_CUT, wx.ART_TOOLBAR, tsize)          
        copiar_bmp = wx.ArtProvider.GetBitmap(wx.ART_COPY, wx.ART_TOOLBAR, tsize)
        pegar_bmp = wx.ArtProvider.GetBitmap(wx.ART_PASTE, wx.ART_TOOLBAR, tsize)
        seleccionarTodo_bmp = wx.ArtProvider.GetBitmap(wx.ART_LIST_VIEW, wx.ART_TOOLBAR,tsize)
        borrar_bmp = wx.ArtProvider.GetBitmap(wx.ART_DELETE, wx.ART_TOOLBAR, tsize)
        #Menu Ver
        #Menu Ayuda
        manual_bmp = wx.ArtProvider.GetBitmap(wx.ART_HELP, wx.ART_TOOLBAR, tsize)
        #--------------------------------------------------------------
        #Agregarlo al frame principal(como la menuBar)
        toolbar = self.CreateToolBar()
        #--------------------------------------------------------------
        #Agregar elementos a toolBar()
        #menuArchivo
        toolbar.AddLabelTool(wx.ID_NEW, u'Nuevo',nuevo_bmp, shortHelp=u'Nuevo', longHelp=u'Crea un nuevo documento')
        toolbar.AddSeparator()
        toolbar.AddLabelTool(wx.ID_OPEN, u'Abrir', abrir_bmp, shortHelp=u'Abrir', longHelp=u'Abre un documento')
        toolbar.AddSeparator()
        toolbar.AddLabelTool(wx.ID_SAVE, u'Guardar', guardar_bmp, shortHelp=u'Guardar', longHelp=u'Guarda el archivo actual')
        toolbar.AddLabelTool(wx.ID_SAVEAS,u'Guardar Como', guardarComo_bmp, shortHelp=u'Guardar Como', longHelp=u'guarda el archivo actual con un nombre determinado')
        toolbar.AddSeparator()
        #menuEditar
        toolbar.AddLabelTool(wx.ID_CUT, u'Cortar', cortar_bmp, shortHelp=u'Cortar', longHelp=u'Corta el texto seleccionado')
        toolbar.AddLabelTool(wx.ID_COPY, u'Copiar', copiar_bmp, shortHelp=u'Copiar', longHelp=u'Copia el texto seleccionado')
        toolbar.AddLabelTool(wx.ID_PASTE, u'Pegar', pegar_bmp, shortHelp=u'Pegar', longHelp=u'Pega el texto copiado ó cortado')
        toolbar.AddSeparator()
        toolbar.AddLabelTool(wx.ID_DELETE, u'Borrar', borrar_bmp, shortHelp=u'Borrar', longHelp=u'Borra todo lo seleccionado')
        toolbar.AddSeparator()
        toolbar.AddLabelTool(wx.ID_HELP,u'Ayuda', manual_bmp, shortHelp=u'Ayuda', longHelp=u'Presenta documentación de ayuda de Editext')
        toolbar.AddSeparator()
        toolbar.AddLabelTool(wx.ID_EXIT, 'Salir', salir_bmp, shortHelp=u'Salir', longHelp=u'Terminar el programa')
        toolbar.AddSeparator()
        #menu Ver
        #Menu Ayuda
        #--------------------------------------------------------------
        #(no lo estoy bindeando)
        # Atamos el boton nuevo del ToolBar() a un evento de ToolBar() wx.EVT_TOOL,
        # con id=wx.ID_NEW que es el identificador del widget, esto reenplaza al usado -1,
        # es mejor por que cada widget tiene que tener un solo identificador
        #    self.Bind(wx.EVT_TOOL, self.OnManual, id=10)
        #--------------------------------------------------------------
        # Agregamos las imagenes a los botones de la ToolBar()
        toolbar.SetToolBitmapSize(tsize)
        #--------------------------------------------------------------
        #Captura el evento cerrar en todas sus formas de self.frame
        self.Bind (wx.EVT_CLOSE, self.OnCerrarVentana)
        #--------------------------------------------------------------
        #Se crea una barra de estado
        self.CreateStatusBar()
        self.SetStatusText(u'EdiText 1.1')
        #Muestre la barra menú
        self.SetMenuBar(menuBar)
        self.Show(True)
         #Funciones de Archivo
    def OnNuevo(self,evt):
        self.contador += 1
        #padre = self -hijo- cuando se cierra la ventana padre se cierran las hijas.
        editor(self, -1, u"Documento no guardado ")
            
    def OnAbrir(self,evt):
        
        #Sacado de la demo y adaptado a mi código, ej declare variable self.dirname poque sino daba error
        self.dirname = ''
        dlg = wx.FileDialog(self, "Abrir archivo", self.dirname, "", "*.*", wx.OPEN)
        if dlg.ShowModal() == wx.ID_OK:
            #usamos la funcion de manejo de archivos filename()
            self.filename=dlg.GetFilename()
            self.dirname=dlg.GetDirectory()
            f=open(self.dirname+'/'+self.filename,'r')
            texto = f.read()
            texto = texto.decode('utf-8') 
            #Esto funciona solamente en linux por el path(ruta) que tiene barras hacia la derecha ' / '
            #en windows las barras son hacia la izquierda ' \ '
            self.tc.SetValue(texto)
            self.tc.SetFocus()
            self.texto = texto
            f.close()
            self.fueGcono = False
            self.textoInicial = self.tc.GetValue()
            dlg.Destroy()
            
    def OnGuardar_como(self,evt):
        #Sacado de la demo y adaptado a mi código
        self.tc.WriteText(u"")
        dlg = wx.FileDialog(self, message="Guardar como", defaultDir=os.getcwd(), defaultFile="", wildcard=wildcard, style=wx.SAVE)
        dlg.SetFilterIndex(3)
        if dlg.ShowModal() == wx.ID_OK:
            #Toma el path
            self.path = dlg.GetPath()
            #Toma el contenido de un textbox
            guardar = self.tc.GetValue()
            #escribir el contenido en un textBox
            f = open(self.path,'a')
            f.write(guardar.encode('utf-8'))
            f.close()
            self.fueGcomo = True
            self.textoInicial = self.tc.GetValue()
        dlg.Destroy()
        
    def OnGuardar(self,evt):
        #Diseñado por mi
        guardar = self.tc.GetValue()
        #Si el archivo no tiene nombre, dirección y no fué Guardado como:
        if self.dirname == False and self.filename == False and self.fueGcomo == False:
            self.OnGuardar_como(self)
        #Si el archivo no fué Guardado como:
        elif self.fueGcomo == True:
            guardar = self.tc.GetValue()
            f = open(self.path,'w')
            f.write(guardar.encode('utf-8'))
            f.close()
            self.fueGcomo = True
            self.textoInicial = self.tc.GetValue()
            print self.dirname, self.filename, self.fueGcomo
        #Si el archivo fué abierto:
        else:
            #Toma todo el texto escrito en el textctrl
            guardar = self.tc.GetValue()
            #Se usa los valores de self.dirname y self.filename determinados al abrir el archivo 
            f=open(self.dirname+'/'+self.filename,'w')
            #Se pone el encpding para que al guardar palabras con acento o Ñ,
            #no de error   
            f.write(guardar.encode('utf-8'))
            f.close()
            #self.fueGcomo = True --------no va
            self.textoInicial = self.tc.GetValue()
            
    def OnSalir(self,evt):
        self.Close()
    #Funciones de Editar
    def OnElegirFuente(self, evt):
        # No se imaginan lo bien que me hizo lograr adaptar esto de la eleccion de fuente. 
        dlg = wx.FontDialog(self, wx.FontData())
        dlg.GetFontData().SetInitialFont(self.tc.GetFont())
        if dlg.ShowModal() == wx.ID_OK:
            self.tc.SetFont(dlg.GetFontData().GetChosenFont())
        dlg.Destroy()
    def OnCortar(self,evt):
        self.tc.Cut()
    
    def OnCopiar(self,evt):
        self.tc.Copy()
        
    def OnPegar(self,evt):
        self.tc.Paste()
        
    def Seleccionar_todo(self,evt):
        self.tc.SelectAll()
        
    def OnBorrar(self,evt):
        x, i = self.tc.GetSelection()
        self.tc.Remove(x, i)
    def OnAcerca_de(self, evt):
        from wx.lib.wordwrap import wordwrap
        info = wx.AboutDialogInfo()
        info.Name = 'EdiText'
        info.Version = '1.1'
        info.Copyright = u'Copyleft Dante Sanfelice'
        info.Description = wordwrap('Editor de texto simple desarrollado como ejercicio de estudio en La escuela San Cayetano',350, wx.ClientDC(self))      
        
        import gpl
        info.License = wordwrap(gpl.licenseText, 500, wx.ClientDC(self))
        info.WebSite = ("")
        info.Developers = [ "Dante Alfredo Sanfelice" ]
        wx.AboutBox(info)
    def OnManual(self,evt):
        ventana = wx.Frame(parent = None, title = u'Ayuda editext', size = (530, 450),style = wx.DEFAULT_FRAME_STYLE ^(wx.MINIMIZE_BOX|wx.MAXIMIZE_BOX |wx.RESIZE_BORDER))
        ventana.CenterOnScreen()
        nav = html.HtmlWindow(ventana , id = -1)
        nav.LoadPage('./html/index.html')
        ventana.Show()
        return(True)
        
    def OnCerrarVentana(self, evet):
        #self.textoInicial = self.tc.GetValue()
        self.textoFinal = self.tc.GetValue()
        #print self.textoInicial
        #print self.textoFinal
        if self.textoInicial == self.textoFinal:
            self.Destroy()
        else:
            
            dlg = wx.MessageDialog(self, 'Desea guardar antes de salir?', 'Aviso', wx.YES_NO | wx.YES_DEFAULT | 
            wx.CANCEL | wx.ICON_QUESTION)
            val = dlg.ShowModal()
            if val == wx.ID_YES:
                self.OnGuardar(self)
                self.Destroy()
            elif val == wx.ID_CANCEL:
                pass
            elif val == wx.ID_NO:
                self.Destroy()
        
#Clase principal, obligatorio crear una instancia de objeto App()
app = wx.App()
#Instanciamos clase editor()
editor(None, -1, u'EdiText')
#Entramos en un bucle esperando eventos
app.MainLoop()


